// API接口配置
import http from './request.js'

// API基础配置
const API_CONFIG = {
  // 开发环境
  development: {
    // baseURL: 'http://192.168.1.106:8081',  // 根据您的截图更新为实际地址
      // baseURL: 'http://192.168.120.31:8036',  // 根据您的截图更新为实际地址
    // baseURL: 'http://blserver.anzaisoft.net:8081',
    // baseURL: 'https://blapi.anzaisoft.net',
        // baseURL: 'http://localhost:8081/wechat-api',
	// baseURL:"https://blserver.anzaisoft.net/wechat-api",
	   baseURL:"https://sczs.n-logistics.cn:4433/wechat-api",
    timeout: 60000
  },
  // 生产环境
  production: {
    // baseURL: 'http://192.168.1.106:8036',  // 请替换为您的生产环境地址
    // baseURL: 'https://blapi.anzaisoft.net',
    // baseURL: 'https://blserver.anzaisoft.net',
	baseURL:"https://sczs.n-logistics.cn:4433/wechat-api",
    timeout: 8000
  }
}

// 获取当前环境配置
const currentEnv = process.env.NODE_ENV || 'development'
const config = API_CONFIG[currentEnv] || API_CONFIG.development

// 设置基础配置
http.setBaseURL(config.baseURL)
http.setTimeout(config.timeout)

// 导出配置
export { config }

// 添加请求拦截器 - 添加token等
http.addRequestInterceptor(function(config) {
  // 确保config.header存在
  if (!config.header) {
    config.header = {}
  }
  
  // 从本地存储获取token
  const token = uni.getStorageSync('user-token')
  
  if (token) {
    // 设置Authorization头
    config.header.Authorization = token
    console.log('✅ 请求已添加token:', token.substring(0, 20) + '...')
  } else {
    console.log('⚠️ 请求未添加token: 用户未登录或token不存在')
  }
  
  // 添加时间戳防止缓存
  if (config.method === 'GET') {
    const timestamp = Date.now()
    const separator = config.url.includes('?') ? '&' : '?'
    config.url += separator + '_t=' + timestamp
  }
  
  // 确保Content-Type存在（对于POST/PUT请求）
  if ((config.method === 'POST' || config.method === 'PUT' || config.method === 'PATCH') && !config.header['Content-Type']) {
    config.header['Content-Type'] = 'application/json'
  }
  
  console.log('🚀 请求拦截器处理完成:', {
    url: config.url,
    method: config.method,
    hasToken: !!token,
    headers: config.header
  })
  
  return config
})

// 添加响应拦截器 - 处理通用逻辑
http.addResponseInterceptor(function(response, config) {
  console.log('📥 响应拦截器收到响应:', {
    url: config.url,
    status: response.status,
    code: response.data?.code,
    message: response.data?.message
  })
  
  // 处理token过期
  if (response.data && response.data.code === 401) {
    console.log('🔐 Token过期，尝试刷新...')
    // 尝试刷新token
    return refreshTokenAndRetry(config)
  }
  
  // 处理其他错误状态码
  if (response.data && response.data.code !== 200) {
    console.log('❌ API返回错误:', response.data)
  }
  
  return response
})

// 刷新token并重试请求的函数
let isRefreshing = false
let failedQueue = []

const processQueue = (error, token = null) => {
  console.log('📋 处理队列中的请求，数量:', failedQueue.length)
  
  failedQueue.forEach((prom, index) => {
    if (error) {
      console.log(`❌ 队列请求 ${index + 1} 失败:`, error.message)
      prom.reject(error)
    } else {
      console.log(`✅ 队列请求 ${index + 1} 成功，使用新token`)
      prom.resolve(token)
    }
  })
  
  failedQueue = []
  console.log('📋 队列处理完成')
}

const refreshTokenAndRetry = async (config) => {
  if (isRefreshing) {
    console.log('🔄 正在刷新token，将请求加入队列...')
    // 如果正在刷新，将请求加入队列
    return new Promise((resolve, reject) => {
      failedQueue.push({ resolve, reject })
    }).then(token => {
      console.log('✅ 从队列中获取到新token，重试请求')
      config.header.Authorization = token
      return http.request(config)
    }).catch(err => {
      console.error('❌ 队列中的请求处理失败:', err)
      return Promise.reject(err)
    })
  }

  console.log('🔄 开始刷新token...')
  isRefreshing = true

  try {
    // 调用刷新token接口
    console.log('📡 调用刷新token接口...')
    const refreshRes = await http.post('/app/api/auth/wx/refreshToken')
    
    console.log('📥 刷新token响应:', refreshRes)
    
    if (refreshRes.data && refreshRes.data.code === 200) {
      const newToken = refreshRes.data.data.token
      console.log('✅ 获取到新token:', newToken.substring(0, 20) + '...')
      
      // 保存新token
      uni.setStorageSync('user-token', newToken)
      
      // 更新当前请求的header
      config.header.Authorization = newToken
      
      // 处理队列中的请求
      processQueue(null, newToken)
      
      // 重试当前请求
      console.log('🔄 使用新token重试请求...')
      return http.request(config)
    } else {
      console.error('❌ 刷新token失败:', refreshRes.data)
      // 刷新失败，清除token并跳转到mine页面进行授权
      uni.removeStorageSync('user-token')
      uni.removeStorageSync('userInfo')
      uni.reLaunch({
        url: '/pages/mine/mine'
      })
      
      processQueue(new Error('刷新token失败'), null)
      return Promise.reject({
        code: 401,
        message: '登录已过期，请重新登录'
      })
    }
  } catch (error) {
    console.error('❌ 刷新token请求失败:', error)
    // 刷新token请求失败
    uni.removeStorageSync('user-token')
    uni.removeStorageSync('userInfo')
    uni.reLaunch({
      url: '/pages/mine/mine'
    })
    
    processQueue(error, null)
    return Promise.reject({
      code: 401,
      message: '登录已过期，请重新登录'
    })
  } finally {
    isRefreshing = false
    console.log('🔄 Token刷新流程结束')
  }
}

// API接口定义
export const API = {
  // 测试token设置
  test: {
    // 测试token是否正确设置
    checkToken: function() {
      console.log('🧪 测试token设置...')
      const token = uni.getStorageSync('user-token')
      console.log('当前存储的token:', token ? token.substring(0, 20) + '...' : '无')
      return http.get('/app/api/test/token')
    }
  },
  
  // 预约相关接口
  appointment: {
    // 获取预约列表
    getList: function(params) {
      return http.get('/app/api/appointment/list', params)
    },
    // 创建预约
    create: function(data) {
      return http.post('/app/api/appointment/create', data)
    },
    
    // 取消预约
    cancel: function(id) {
      return http.put('/app/api/appointment/cancel/' + id)
    },
    // 根据仓库ID获取预约
    getAppointmentByWarehouseId: function(warehouseId) {
      return http.get('/app/api/appointment/warehouse/' + warehouseId)
    }
  },


  // 认证相关接口
  auth: {
    // 微信登录
    wxLogin: function(data) {
      return http.post('/app/api/auth/wx/login', data)
    },
    
    // 解密并绑定手机号
    decryptPhone: function(data) {
      return http.post('/app/api/auth/wx/decryptPhone', data)
    },
    
    // 手动绑定手机号
    bindPhone: function(data) {
      return http.post('/app/api/auth/wx/bindPhone', data)
    },
    
    // 刷新token
    refreshToken: function() {
      return http.post('/app/api/auth/wx/refreshToken')
    }
  },

  // Banner相关接口
  banner: {
    // 获取Banner列表
    getList: function(params) {
      return http.get('/app/api/common/banner/list', params)
    }
  },

  // 首页相关接口
  home: {
    // 获取首页数据
    getData: function(params) {
      return http.get('/app/api/home/data', params)
    },
    // 获取仓库类型
    getWarehouseTypes: function(params) {
      return http.get('/app/api/warehouse/types', params)
    }
  },

  // 资讯相关接口
  news: {
    // 获取资讯列表
    getList: function(params) {
      return http.get('/app/api/news/list', params)
    },
    
    // 获取资讯详情
    getDetail: function(id) {
      return http.get('/app/api/news/' + id)
    },
    // 获取资讯分类（旧）
    getNewsCategory: function(params) {
      return http.get('/app/api/news/category', params)
    },
    // 获取资讯分类（新别名，推荐使用）
    getCategoryList: function(params) {
      return http.get('/app/api/news/category', params)
    }
  },

  // 园区相关接口
  park: {
    // 获取园区列表
    getList: function(params) {
      return http.get('/app/api/park/list', params)
    },
    
    // 获取园区区域列表
    getAreaList: function(params) {
      return http.get('/app/api/park/areaList', params)
    },

    // 获取园区类型列表
    getParkTypeList: function(params) {
      return http.get('/app/api/park/typeList', params)
    },
    
    // 获取园区详情
    getDetail: function(id) {
      return http.get('/app/api/park/' + id)
    },
    
    // 获取园区推荐仓库
    getRecommendWarehouses: function(parkId, params = {}) {
      return http.get(`/app/api/park/${parkId}/recommend/warehouses`, params)
    }
  },

  // 搜索相关接口
  search: {
    // 全局搜索
    global: function(params) {
      return http.get('/app/api/common/search', params)
    }
  },

  // 用户相关接口
  user: {
    // 获取用户信息
    getUserInfo: function() {
      return http.get('/app/api/user/info')
    },
    
    // 根据用户ID获取用户信息
    getUserInfoById: function(userId) {
      return http.get('/app/api/user/info/' + userId)
    },
    
    // 更新用户信息
    updateUserInfo: function(data) {
      return http.put('/app/api/user/update', data)
    },
    
    // 上传头像
    uploadAvatar: function(filePath) {
      return http.upload('/app/api/user/uploadAvatar', filePath, {
        name: 'file',
        formData: {
          type: 'avatar'
        }
      })
    }
  },

  // 仓库相关接口
  warehouse: {
    // 获取仓库列表
    getList: function(params) {
      return http.get('/app/api/warehouse/list', params)
    },
    
    // 获取仓库详情
    getDetail: function(id) {
      return http.get('/app/api/warehouse/' + id)
    },
    // 获取仓库类型
    getWarehouseTypes: function() {
      return http.get('/app/api/warehouse/types')
    },
    // 获取仓库标签
    getWarehouseTags: function() {
      return http.get('/app/api/warehouse/tags')
    },
  },

  // 收藏相关接口
  favorite: {
    // 添加收藏
    add: function(data) {
      return http.post('/app/api/favorite/add', data)
    },
    
    // 取消收藏
    cancel: function(data) {
      return http.delete('/app/api/favorite/cancel', data)
    },
    
    // 获取收藏列表
    getList: function(params) {
      return http.get('/app/api/favorite/list', params)
    },
    
    // 检查是否已收藏
    check: function(params) {
      return http.post('/app/api/favorite/check', params)
    }
  },

  // 文件上传相关接口
  file: {
    // 上传图片
    uploadImage: function(filePath) {
      return http.upload('/app/api/file/upload/image', filePath, {
        name: 'file',
        formData: {
          type: 'image'
        }
      })
    },
    
    // 上传文件
    uploadFile: function(filePath, type) {
      type = type || 'file'
      return http.upload('/app/api/file/upload', filePath, {
        name: 'file',
        formData: {
          type: type
        }
      })
    },
    
    // 下载文件
    downloadFile: function(fileId) {
      return http.download('/app/api/file/download/' + fileId)
    }
  }
}

// 导出API对象和默认http实例
export default http

// 工具函数：验证token设置
export function validateTokenSetup() {
  console.log('🔍 验证token设置...')
  
  // 检查本地存储的token
  const token = uni.getStorageSync('user-token')
  console.log('本地存储token:', token ? '✅ 存在' : '❌ 不存在')
  
  if (token) {
    console.log('Token内容:', token.substring(0, 20) + '...')
  }
  
  // 检查拦截器是否设置
  console.log('请求拦截器状态: ✅ 已设置')
  console.log('响应拦截器状态: ✅ 已设置')
  
  return {
    hasToken: !!token,
    tokenLength: token ? token.length : 0,
    interceptorsSet: true
  }
} 